home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / gfx / misc / gnuplot-src.lha / gnuplot-3.7.1src / gnuplot-3.7.1.lha / gnuplot-3.7.1 / show.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-09-29  |  46.6 KB  |  1,736 lines
  1. #ifndef lint@¬‚ŸîSid = "$Id: show.c,v 1.23.2.2 1999/09/29 17:17:26 lhecking Exp $";
  2. #endif
  3.  
  4. /* GNUPLOT - show.c */
  5.  
  6. /*[
  7.  * Copyright 1986 - 1993, 1998   Thomas Williams, Colin Kelley
  8.  *
  9.  * Permission to use, copy, and distribute this software and its
  10.  * documentation for any purpose with or without fee is hereby granted,
  11.  * provided that the above copyright notice appear in all copies and
  12.  * that both that copyright notice and this permission notice appear
  13.  * in supporting documentation.
  14.  *
  15.  * Permission to modify the software is granted, but not the right to
  16.  * distribute the complete modified source code.  Modifications are to
  17.  * be distributed as patches to the released version.  Permission to
  18.  * distribute binaries produced by compiling modified sources is granted,
  19.  * provided you
  20.  *   1. distribute the corresponding source modifications from the
  21.  *    released version in the form of a patch file along with the binaries,
  22.  *   2. add special version identification to distinguish your version
  23.  *    in addition to the base release version number,
  24.  *   3. provide your name and address as the primary contact for the
  25.  *    support of your modified version, and
  26.  *   4. retain our contact information in regard to use of the base
  27.  *    software.
  28.  * Permission to distribute the released version of the source code along
  29.  * with corresponding source modifications in the form of a patch file is
  30.  * granted with same provisions 2 through 4 for binary distributions.
  31.  *
  32.  * This software is provided "as is" without express or implied warranty
  33.  * to the extent permitted by applicable law.
  34. ]*/
  35.  
  36.  
  37. /*
  38.  * 19 September 1992  Lawrence Crowl  (crowl@cs.orst.edu)
  39.  * Added user-specified bases for log scaling.
  40.  */
  41.  
  42.  
  43. #include "plot.h"
  44. #include "setshow.h"
  45.  
  46. #define DEF_FORMAT   "%g"    /* default format for tic mark labels */
  47. #define SIGNIF (0.01)        /* less than one hundredth of a tic mark */
  48.  
  49.  
  50. /* input data, parsing variables */
  51.  
  52. extern TBOOLEAN is_3d_plot;
  53.  
  54. /* From version.c, used in show_version () */
  55. extern char version[];
  56. extern char patchlevel[];
  57. extern char date[];
  58. extern char gnuplot_copyright[];
  59. extern char faq_location[];
  60. extern char bug_email[];
  61. extern char help_email[];
  62.  
  63.  
  64. #ifndef TIMEFMT
  65. #define TIMEFMT "%d/%m/%y,%H:%M"
  66. #endif
  67. /* format for date/time for reading time in datafile */
  68.  
  69.  
  70.  
  71. /******** Local functions ********/
  72.  
  73. static void show_style __PROTO((char name[], enum PLOT_STYLE style));
  74. static void show_range __PROTO((int axis, double min, double max, int autosc, char *text));
  75. static void show_zero __PROTO((void));
  76. static void show_border __PROTO((void));
  77. static void show_dgrid3d __PROTO((void));
  78. static void show_offsets __PROTO((void));
  79. static void show_samples __PROTO((void));
  80. static void show_isosamples __PROTO((void));
  81. static void show_output __PROTO((void));
  82. static void show_view __PROTO((void));
  83. static void show_size __PROTO((void));
  84. static void show_origin __PROTO((void));
  85. static void show_title __PROTO((void));
  86. static void show_xyzlabel __PROTO((char *name, label_struct * label));
  87. static void show_angles __PROTO((void));
  88. static void show_boxwidth __PROTO((void));
  89. static void show_bars __PROTO((void));
  90. static void show_xzeroaxis __PROTO((void));
  91. static void show_yzeroaxis __PROTO((void));
  92. static void show_label __PROTO((int tag));
  93. static void show_linestyle __PROTO((int tag));
  94. static void show_arrow __PROTO((int tag));
  95. static void show_grid __PROTO((void));
  96. static void show_key __PROTO((void));
  97. static void show_keytitle __PROTO((void));
  98. static void show_mtics __PROTO((int mini, double freq, char *name));
  99. static void show_pointsize __PROTO((void));
  100. static void show_encoding __PROTO((void));
  101. static void show_polar __PROTO((void));
  102. static void show_parametric __PROTO((void));
  103. static void show_tics __PROTO((int showx, int showy, int showz, int showx2, int showy2));
  104. static void show_ticdef __PROTO((int tics, int axis, struct ticdef * tdef, char *text, int rotate_tics, char *ticfmt));
  105. static void show_term __PROTO((void));
  106. static void show_plot __PROTO((void));
  107. static void show_autoscale __PROTO((void));
  108. static void show_clip __PROTO((void));
  109. static void show_contour __PROTO((void));
  110. static void show_mapping __PROTO((void));
  111. static void show_format __PROTO((void));
  112. static void show_logscale __PROTO((void));
  113. static void show_variables __PROTO((void));
  114. static void show_surface __PROTO((void));
  115. static void show_hidden3d __PROTO((void));
  116. static void show_label_contours __PROTO((void));
  117. static void show_margin __PROTO((void));
  118. static void show_position __PROTO((struct position * pos));
  119.  
  120. static TBOOLEAN show_one __PROTO((void));
  121. static TBOOLEAN show_two __PROTO((void));
  122. static void show_timefmt __PROTO((void));
  123. static void show_locale __PROTO((void));
  124. static void show_missing __PROTO((void));
  125. static void show_datatype __PROTO((char *name, int axis));
  126. static void show_locale __PROTO((void));
  127.  
  128. /* following code segment appears over and over again */
  129.  
  130. #define SHOW_NUM_OR_TIME(x, axis) \
  131. do{if (datatype[axis]==TIME) { \
  132.   char s[80]; char *p; \
  133.   putc('"', stderr);   \
  134.   gstrftime(s,80,timefmt,(double)(x)); \
  135.   for(p=s; *p; ++p) {\
  136.    if ( *p == '\t' ) fputs("\\t",stderr);\
  137.    else if (*p == '\n') fputs("\\n",stderr); \
  138.    else if ( *p > 126 || *p < 32 ) fprintf(stderr,"\\%03o",*p);\
  139.    else putc(*p, stderr);\
  140.   }\
  141.   putc('"', stderr);\
  142.  } else {\
  143.   fprintf(stderr,"%#g",x);\
  144. }} while(0)
  145.  
  146.  
  147. /******* The 'show' command *******/
  148. void show_command()
  149. {
  150.     /* show at is undocumented/hidden... */
  151.     static char GPFAR showmess[] =
  152.     "valid set options:  [] = choose one, {} means optional\n\n\
  153. \t'all',  'angles',  'arrow',  'autoscale',  'bar', 'border',  'boxwidth',\n\
  154. \t'clip', 'cntrparam', 'contour',  'data',  'dgrid3d',  'dummy',\n\
  155. \t'encoding', 'format', 'function',  'grid',  'hidden',  'isosamples',\n\
  156. \t'key', 'label', 'linestyle', 'locale', 'logscale', 'mapping', 'margin',\n\
  157. \t'missing', 'offsets', 'origin', 'output', 'plot', 'parametric',\n\
  158. \t'pointsize', 'polar', '[rtuv]range', 'samples', 'size', 'terminal',\n\
  159. \t'tics', 'timestamp', 'timefmt', 'title', 'variables', 'version',\n\
  160. \t'view',   '[xyz]{2}label',   '[xyz]{2}range',   '{m}[xyz]{2}tics',\n\
  161. \t'[xyz]{2}[md]tics',   '[xyz]{2}zeroaxis',   '[xyz]data',   'zero',\n\
  162. \t'zeroaxis'";
  163.  
  164.  
  165.     c_token++;
  166.  
  167.     if (!show_one() && !show_two())
  168.     int_error(showmess, c_token);
  169.     screen_ok = FALSE;
  170.     (void) putc('\n', stderr);
  171. }
  172.  
  173. /* return TRUE if a command match, FALSE if not */
  174. static TBOOLEAN
  175.  show_one()
  176. {
  177.     if (almost_equals(c_token, "ac$tion_table") ||
  178.     equals(c_token, "at")) {
  179.     c_token++;
  180.     show_at();
  181.     c_token++;
  182.     } else if (almost_equals(c_token, "ar$row")) {
  183.     struct value a;
  184.     int tag = 0;
  185.  
  186.     c_token++;
  187.     if (!END_OF_COMMAND) {
  188.         tag = (int) real(const_express(&a));
  189.         if (tag <= 0)
  190.         int_error("tag must be > zero", c_token);
  191.     }
  192.     (void) putc('\n', stderr);
  193.     show_arrow(tag);
  194.     } else if (almost_equals(c_token, "au$toscale")) {
  195.     (void) putc('\n', stderr);
  196.     show_autoscale();
  197.     c_token++;
  198.     } else if (almost_equals(c_token, "b$ars")) {
  199.     (void) putc('\n', stderr);
  200.     show_bars();
  201.     c_token++;
  202.     } else if (almost_equals(c_token, "bor$der")) {
  203.     (void) putc('\n', stderr);
  204.     show_border();
  205.     c_token++;
  206.     } else if (almost_equals(c_token, "box$width")) {
  207.     (void) putc('\n', stderr);
  208.     show_boxwidth();
  209.     c_token++;
  210.     } else if (almost_equals(c_token, "c$lip")) {
  211.     (void) putc('\n', stderr);
  212.     show_clip();
  213.     c_token++;
  214.     } else if (almost_equals(c_token, "ma$pping")) {
  215.     (void) putc('\n', stderr);
  216.     show_mapping();
  217.     c_token++;
  218.     } else if (almost_equals(c_token, "co$ntour") ||
  219.            almost_equals(c_token, "cn$trparam")) {
  220.     (void) putc('\n', stderr);
  221.     show_contour();
  222.     c_token++;
  223.     } else if (almost_equals(c_token, "da$ta")) {
  224.     c_token++;
  225.     if (!almost_equals(c_token, "s$tyle"))
  226.         int_error("expecting keyword 'style'", c_token);
  227.     (void) putc('\n', stderr);
  228.     show_style("data", data_style);
  229.     c_token++;
  230.     } else if (almost_equals(c_token, "dg$rid3d")) {
  231.     (void) putc('\n', stderr);
  232.     show_dgrid3d();
  233.     c_token++;
  234.     } else if (almost_equals(c_token, "du$mmy")) {
  235.     (void) fprintf(stderr, "\n\tdummy variables are \"%s\" and \"%s\"\n",
  236.                dummy_var[0], dummy_var[1]);
  237.     c_token++;
  238.     } else if (almost_equals(c_token, "fo$rmat")) {
  239.     show_format();
  240.     c_token++;
  241.     } else if (almost_equals(c_token, "fu$nctions")) {
  242.     c_token++;
  243.     if (almost_equals(c_token, "s$tyle")) {
  244.         (void) putc('\n', stderr);
  245.         show_style("functions", func_style);
  246.         c_token++;
  247.     } else
  248.         show_functions();
  249.     } else if (almost_equals(c_token, "lo$gscale")) {
  250.     (void) putc('\n', stderr);
  251.     show_logscale();
  252.     c_token++;
  253.     } else if (almost_equals(c_token, "of$fsets")) {
  254.     (void) putc('\n', stderr);
  255.     show_offsets();
  256.     c_token++;
  257.     } else if (almost_equals(c_token, "ma$rgin")) {
  258.     (void) putc('\n', stderr);
  259.     show_margin();
  260.     c_token++;
  261.     } else if (almost_equals(c_token, "o$utput")) {
  262.     (void) putc('\n', stderr);
  263.     show_output();
  264.     c_token++;
  265.     } else if (almost_equals(c_token, "tit$le")) {
  266.     (void) putc('\n', stderr);
  267.     show_xyzlabel("title", &title);
  268.     c_token++;
  269.     } else if (almost_equals(c_token, "mis$sing")) {
  270.     (void) putc('\n', stderr);
  271.     show_missing();
  272.     c_token++;
  273.     } else if (almost_equals(c_token, "xl$abel")) {
  274.     (void) putc('\n', stderr);
  275.     show_xyzlabel("xlabel", &xlabel);
  276.     c_token++;
  277.     } else if (almost_equals(c_token, "x2l$abel")) {
  278.     (void) putc('\n', stderr);
  279.     show_xyzlabel("x2label", &x2label);
  280.     c_token++;
  281.     } else if (almost_equals(c_token, "yl$abel")) {
  282.     (void) putc('\n', stderr);
  283.     show_xyzlabel("ylabel", &ylabel);
  284.     c_token++;
  285.     } else if (almost_equals(c_token, "y2l$abel")) {
  286.     (void) putc('\n', stderr);
  287.     show_xyzlabel("y2label", &y2label);
  288.     c_token++;
  289.     } else if (almost_equals(c_token, "zl$abel")) {
  290.     (void) putc('\n', stderr);
  291.     show_xyzlabel("zlabel", &zlabel);
  292.     c_token++;
  293.     } else if (almost_equals(c_token, "keyt$itle")) {
  294.     (void) putc('\n', stderr);
  295.     show_keytitle();
  296.     c_token++;
  297.     } else if (almost_equals(c_token, "xda$ta")) {
  298.     (void) putc('\n', stderr);
  299.     show_datatype("xdata", FIRST_X_AXIS);
  300.     c_token++;
  301.     } else if (almost_equals(c_token, "yda$ta")) {
  302.     (void) putc('\n', stderr);
  303.     show_datatype("ydata", FIRST_Y_AXIS);
  304.     c_token++;
  305.     } else if (almost_equals(c_token, "x2da$ta")) {
  306.     (void) putc('\n', stderr);
  307.     show_datatype("x2data", SECOND_X_AXIS);
  308.     c_token++;
  309.     } else if (almost_equals(c_token, "y2da$ta")) {
  310.     (void) putc('\n', stderr);
  311.     show_datatype("y2data", SECOND_Y_AXIS);
  312.     c_token++;
  313.     } else if (almost_equals(c_token, "zda$ta")) {
  314.     (void) putc('\n', stderr);
  315.     show_datatype("zdata", FIRST_Z_AXIS);
  316.     c_token++;
  317.     } else if (almost_equals(c_token, "timef$mt")) {
  318.     (void) putc('\n', stderr);
  319.     show_timefmt();
  320.     c_token++;
  321.     } else if (almost_equals(c_token, "loca$le")) {
  322.     (void) putc('\n', stderr);
  323.     show_locale();
  324.     c_token++;
  325.     } else if (almost_equals(c_token, "xzero$axis")) {
  326.     (void) putc('\n', stderr);
  327.     show_xzeroaxis();
  328.     c_token++;
  329.     } else if (almost_equals(c_token, "yzero$axis")) {
  330.     (void) putc('\n', stderr);
  331.     show_yzeroaxis();
  332.     c_token++;
  333.     } else if (almost_equals(c_token, "zeroa$xis")) {
  334.     (void) putc('\n', stderr);
  335.     show_xzeroaxis();
  336.     show_yzeroaxis();
  337.     c_token++;
  338.     } else if (almost_equals(c_token, "la$bel")) {
  339.     struct value a;
  340.     int tag = 0;
  341.  
  342.     c_token++;
  343.     if (!END_OF_COMMAND) {
  344.         tag = (int) real(const_express(&a));
  345.         if (tag <= 0)
  346.         int_error("tag must be > zero", c_token);
  347.     }
  348.     (void) putc('\n', stderr);
  349.     show_label(tag);
  350.     } else if (almost_equals(c_token, "li$nestyle") || equals(c_token, "ls")) {
  351.     struct value a;
  352.     int tag = 0;
  353.  
  354.     c_token++;
  355.     if (!END_OF_COMMAND) {
  356.         tag = (int) real(const_express(&a));
  357.         if (tag <= 0)
  358.         int_error("tag must be > zero", c_token);
  359.     }
  360.     (void) putc('\n', stderr);
  361.     show_linestyle(tag);
  362.     } else if (almost_equals(c_token, "g$rid")) {
  363.     (void) putc('\n', stderr);
  364.     show_grid();
  365.     c_token++;
  366.     } else if (almost_equals(c_token, "mxt$ics")) {
  367.     (void) putc('\n', stderr);
  368.     show_mtics(mxtics, mxtfreq, "x");
  369.     c_token++;
  370.     } else if (almost_equals(c_token, "myt$ics")) {
  371.     (void) putc('\n', stderr);
  372.     show_mtics(mytics, mytfreq, "y");
  373.     c_token++;
  374.     } else if (almost_equals(c_token, "mzt$ics")) {
  375.     (void) putc('\n', stderr);
  376.     show_mtics(mztics, mztfreq, "z");
  377.     c_token++;
  378.     } else if (almost_equals(c_token, "mx2t$ics")) {
  379.     (void) putc('\n', stderr);
  380.     show_mtics(mx2tics, mx2tfreq, "x2");
  381.     c_token++;
  382.     } else if (almost_equals(c_token, "my2t$ics")) {
  383.     (void) putc('\n', stderr);
  384.     show_mtics(my2tics, my2tfreq, "y2");
  385.     c_token++;
  386.     } else if (almost_equals(c_token, "k$ey")) {
  387.     (void) putc('\n', stderr);
  388.     show_key();
  389.     c_token++;
  390.     } else
  391.     return (FALSE);
  392.     return TRUE;
  393. }
  394.  
  395. /* return TRUE if a command match, FALSE if not */
  396. static TBOOLEAN
  397.  show_two()
  398. {
  399.     if (almost_equals(c_token, "p$lot")) {
  400.     (void) putc('\n', stderr);
  401.     show_plot();
  402.     c_token++;
  403.     } else if (almost_equals(c_token, "par$ametric")) {
  404.     (void) putc('\n', stderr);
  405.     show_parametric();
  406.     c_token++;
  407.     } else if (almost_equals(c_token, "poi$ntsize")) {
  408.     (void) putc('\n', stderr);
  409.     show_pointsize();
  410.     c_token++;
  411.     } else if (almost_equals(c_token, "enc$oding")) {
  412.     (void) putc('\n', stderr);
  413.     show_encoding();
  414.     c_token++;
  415.     } else if (almost_equals(c_token, "pol$ar")) {
  416.     (void) putc('\n', stderr);
  417.     show_polar();
  418.     c_token++;
  419.     } else if (almost_equals(c_token, "an$gles")) {
  420.     (void) putc('\n', stderr);
  421.     show_angles();
  422.     c_token++;
  423.     } else if (almost_equals(c_token, "ti$cs")) {
  424.     (void) putc('\n', stderr);
  425.     show_tics(TRUE, TRUE, TRUE, TRUE, TRUE);
  426.     c_token++;
  427.     } else if (almost_equals(c_token, "tim$estamp")) {
  428.     (void) putc('\n', stderr);
  429.     show_xyzlabel("time", &timelabel);
  430.     fprintf(stderr, "\twritten in %s corner\n", (timelabel_bottom ? "bottom" : "top"));
  431.     if (timelabel_rotate)
  432.         fputs("\trotated if the terminal allows it\n\t", stderr);
  433.     else
  434.         fputs("\tnot rotated\n\t", stderr);
  435.     c_token++;
  436.     } else if (almost_equals(c_token, "su$rface")) {
  437.     (void) putc('\n', stderr);
  438.     show_surface();
  439.     c_token++;
  440.     } else if (almost_equals(c_token, "hi$dden3d")) {
  441.     (void) putc('\n', stderr);
  442.     show_hidden3d();
  443.     c_token++;
  444.     } else if (almost_equals(c_token, "cla$bel")) {
  445.     (void) putc('\n', stderr);
  446.     show_label_contours();
  447.     c_token++;
  448.     } else if (almost_equals(c_token, "xti$cs")) {
  449.     show_tics(TRUE, FALSE, FALSE, TRUE, FALSE);
  450.     c_token++;
  451.     } else if (almost_equals(c_token, "yti$cs")) {
  452.     show_tics(FALSE, TRUE, FALSE, FALSE, TRUE);
  453.     c_token++;
  454.     } else if (almost_equals(c_token, "zti$cs")) {
  455.     show_tics(FALSE, FALSE, TRUE, FALSE, FALSE);
  456.     c_token++;
  457.     } else if (almost_equals(c_token, "x2ti$cs")) {
  458.     show_tics(FALSE, FALSE, FALSE, TRUE, FALSE);
  459.     c_token++;
  460.     } else if (almost_equals(c_token, "y2ti$cs")) {
  461.     show_tics(FALSE, FALSE, FALSE, FALSE, TRUE);
  462.     c_token++;
  463.     } else if (almost_equals(c_token, "xdti$cs")) {
  464.     show_tics(TRUE, FALSE, FALSE, TRUE, FALSE);
  465.     c_token++;
  466.     } else if (almost_equals(c_token, "ydti$cs")) {
  467.     show_tics(FALSE, TRUE, FALSE, FALSE, TRUE);
  468.     c_token++;
  469.     } else if (almost_equals(c_token, "zdti$cs")) {
  470.     show_tics(FALSE, FALSE, TRUE, FALSE, FALSE);
  471.     c_token++;
  472.     } else if (almost_equals(c_token, "x2dti$cs")) {
  473.     show_tics(FALSE, FALSE, FALSE, TRUE, FALSE);
  474.     c_token++;
  475.     } else if (almost_equals(c_token, "y2dti$cs")) {
  476.     show_tics(FALSE, FALSE, FALSE, FALSE, TRUE);
  477.     c_token++;
  478.     } else if (almost_equals(c_token, "xmti$cs")) {
  479.     show_tics(TRUE, FALSE, FALSE, TRUE, FALSE);
  480.     c_token++;
  481.     } else if (almost_equals(c_token, "ymti$cs")) {
  482.     show_tics(FALSE, TRUE, FALSE, FALSE, TRUE);
  483.     c_token++;
  484.     } else if (almost_equals(c_token, "zmti$cs")) {
  485.     show_tics(FALSE, FALSE, TRUE, FALSE, FALSE);
  486.     c_token++;
  487.     } else if (almost_equals(c_token, "x2mti$cs")) {
  488.     show_tics(FALSE, FALSE, FALSE, TRUE, FALSE);
  489.     c_token++;
  490.     } else if (almost_equals(c_token, "y2mti$cs")) {
  491.     show_tics(FALSE, FALSE, FALSE, FALSE, TRUE);
  492.     c_token++;
  493.     } else if (almost_equals(c_token, "sa$mples")) {
  494.     (void) putc('\n', stderr);
  495.     show_samples();
  496.     c_token++;
  497.     } else if (almost_equals(c_token, "isosa$mples")) {
  498.     (void) putc('\n', stderr);
  499.     show_isosamples();
  500.     c_token++;
  501.     } else if (almost_equals(c_token, "si$ze")) {
  502.     (void) putc('\n', stderr);
  503.     show_size();
  504.     c_token++;
  505.     } else if (almost_equals(c_token, "orig$in")) {
  506.     (void) putc('\n', stderr);
  507.     show_origin();
  508.     c_token++;
  509.     } else if (almost_equals(c_token, "t$erminal")) {
  510.     (void) putc('\n', stderr);
  511.     show_term();
  512.     c_token++;
  513.     } else if (almost_equals(c_token, "rr$ange")) {
  514.     (void) putc('\n', stderr);
  515.     show_range(R_AXIS, rmin, rmax, autoscale_r, "r");
  516.     c_token++;
  517.     } else if (almost_equals(c_token, "tr$ange")) {
  518.     (void) putc('\n', stderr);
  519.     show_range(T_AXIS, tmin, tmax, autoscale_t, "t");
  520.     c_token++;
  521.     } else if (almost_equals(c_token, "ur$ange")) {
  522.     (void) putc('\n', stderr);
  523.     show_range(U_AXIS, umin, umax, autoscale_u, "u");
  524.     c_token++;
  525.     } else if (almost_equals(c_token, "vi$ew")) {
  526.     (void) putc('\n', stderr);
  527.     show_view();
  528.     c_token++;
  529.     } else if (almost_equals(c_token, "vr$ange")) {
  530.     (void) putc('\n', stderr);
  531.     show_range(V_AXIS, vmin, vmax, autoscale_v, "v");
  532.     c_token++;
  533.     } else if (almost_equals(c_token, "v$ariables")) {
  534.     show_variables();
  535.     c_token++;
  536.     } else if (almost_equals(c_token, "ve$rsion")) {
  537.     show_version(stderr);
  538.     c_token++;
  539.     if (almost_equals(c_token, "l$ong")) {
  540.         show_version_long();
  541.         c_token++;
  542.     }
  543.     } else if (almost_equals(c_token, "xr$ange")) {
  544.     (void) putc('\n', stderr);
  545.     show_range(FIRST_X_AXIS, xmin, xmax, autoscale_x, "x");
  546.     c_token++;
  547.     } else if (almost_equals(c_token, "yr$ange")) {
  548.     (void) putc('\n', stderr);
  549.     show_range(FIRST_Y_AXIS, ymin, ymax, autoscale_y, "y");
  550.     c_token++;
  551.     } else if (almost_equals(c_token, "x2r$ange")) {
  552.     (void) putc('\n', stderr);
  553.     show_range(SECOND_X_AXIS, x2min, x2max, autoscale_x2, "x2");
  554.     c_token++;
  555.     } else if (almost_equals(c_token, "y2r$ange")) {
  556.     (void) putc('\n', stderr);
  557.     show_range(SECOND_Y_AXIS, y2min, y2max, autoscale_y2, "y2");
  558.     c_token++;
  559.     } else if (almost_equals(c_token, "zr$ange")) {
  560.     (void) putc('\n', stderr);
  561.     show_range(FIRST_Z_AXIS, zmin, zmax, autoscale_z, "z");
  562.     c_token++;
  563.     } else if (almost_equals(c_token, "z$ero")) {
  564.     (void) putc('\n', stderr);
  565.     show_zero();
  566.     c_token++;
  567.     } else if (almost_equals(c_token, "a$ll")) {
  568.     c_token++;
  569.     show_version(stderr);
  570.     show_autoscale();
  571.     show_bars();
  572.     show_border();
  573.     show_boxwidth();
  574.     show_clip();
  575.     show_contour();
  576.     show_dgrid3d();
  577.     show_mapping();
  578.     (void) fprintf(stderr, "\tdummy variables are \"%s\" and \"%s\"\n",
  579.                dummy_var[0], dummy_var[1]);
  580.     show_format();
  581.     show_style("data", data_style);
  582.     show_style("functions", func_style);
  583.     show_grid();
  584.     show_xzeroaxis();
  585.     show_yzeroaxis();
  586.     show_label(0);
  587.     show_arrow(0);
  588.     show_linestyle(0);
  589.     show_keytitle();
  590.     show_key();
  591.     show_logscale();
  592.     show_offsets();
  593.     show_margin();
  594.     show_output();
  595.     show_parametric();
  596.     show_pointsize();
  597.     show_encoding();
  598.     show_polar();
  599.     show_angles();
  600.     show_samples();
  601.     show_isosamples();
  602.     show_view();
  603.     show_surface();
  604. #ifndef LITE
  605.     show_hidden3d();
  606. #endif
  607.     show_size();
  608.     show_origin();
  609.     show_term();
  610.     show_tics(TRUE, TRUE, TRUE, TRUE, TRUE);
  611.     show_mtics(mxtics, mxtfreq, "x");
  612.     show_mtics(mytics, mytfreq, "y");
  613.     show_mtics(mztics, mztfreq, "z");
  614.     show_mtics(mx2tics, mx2tfreq, "x2");
  615.     show_mtics(my2tics, my2tfreq, "y2");
  616.     show_xyzlabel("time", &timelabel);
  617.     if (parametric || polar) {
  618.         if (!is_3d_plot)
  619.         show_range(T_AXIS, tmin, tmax, autoscale_t, "t");
  620.         else {
  621.         show_range(U_AXIS, umin, umax, autoscale_u, "u");
  622.         show_range(V_AXIS, vmin, vmax, autoscale_v, "v");
  623.         }
  624.     }
  625.     show_range(FIRST_X_AXIS, xmin, xmax, autoscale_x, "x");
  626.     show_range(FIRST_Y_AXIS, ymin, ymax, autoscale_y, "y");
  627.     show_range(SECOND_X_AXIS, x2min, x2max, autoscale_x2, "x2");
  628.     show_range(SECOND_Y_AXIS, y2min, y2max, autoscale_y2, "y2");
  629.     show_range(FIRST_Z_AXIS, zmin, zmax, autoscale_z, "z");
  630.     show_xyzlabel("title", &title);
  631.     show_xyzlabel("xlabel", &xlabel);
  632.     show_xyzlabel("ylabel", &ylabel);
  633.     show_xyzlabel("zlabel", &zlabel);
  634.     show_xyzlabel("x2label", &x2label);
  635.     show_xyzlabel("y2label", &y2label);
  636.     show_datatype("xdata", FIRST_X_AXIS);
  637.     show_datatype("ydata", FIRST_Y_AXIS);
  638.     show_datatype("x2data", SECOND_X_AXIS);
  639.     show_datatype("y2data", SECOND_Y_AXIS);
  640.     show_datatype("zdata", FIRST_Z_AXIS);
  641.     show_timefmt();
  642.     show_locale();
  643.     show_zero();
  644.     show_missing();
  645.     show_plot();
  646.     show_variables();
  647.     show_functions();
  648.     c_token++;
  649.     } else
  650.     return (FALSE);
  651.     return (TRUE);
  652. }
  653.  
  654.  
  655. /*********** support functions for 'show'  **********/
  656. /* perhaps these need to be put into a constant array ? */
  657. static void show_style(name, style)
  658. char name[];
  659. enum PLOT_STYLE style;
  660. {
  661.     fprintf(stderr, "\t%s are plotted with ", name);
  662.     switch (style) {
  663.     case LINES:
  664.     fputs("lines\n", stderr);
  665.     break;
  666.     case POINTSTYLE:
  667.     fputs("points\n", stderr);
  668.     break;
  669.     case IMPULSES:
  670.     fputs("impulses\n", stderr);
  671.     break;
  672.     case LINESPOINTS:
  673.     fputs("linespoints\n", stderr);
  674.     break;
  675.     case DOTS:
  676.     fputs("dots\n", stderr);
  677.     break;
  678.     case YERRORBARS:
  679.     fputs("yerrorbars\n", stderr);
  680.     break;
  681.     case XERRORBARS:
  682.     fputs("xerrorbars\n", stderr);
  683.     break;
  684.     case XYERRORBARS:
  685.     fputs("xyerrorbars\n", stderr);
  686.     break;
  687.     case BOXES:
  688.     fputs("boxes\n", stderr);
  689.     break;
  690.     case BOXERROR:
  691.     fputs("boxerrorbars\n", stderr);
  692.     break;
  693.     case BOXXYERROR:
  694.     fputs("boxxyerrorbars\n", stderr);
  695.     break;
  696.     case STEPS:
  697.     fputs("steps\n", stderr);
  698.     break;
  699.     case FSTEPS:
  700.     fputs("fsteps\n", stderr);
  701.     break;
  702.     case HISTEPS:
  703.     fputs("histeps\n", stderr);
  704.     break;
  705.     case VECTOR:
  706.     fputs("vector\n", stderr);
  707.     break;
  708.     case FINANCEBARS:
  709.     fputs("financebars\n", stderr);
  710.     break;
  711.     case CANDLESTICKS:
  712.     fputs("candlesticsks\n", stderr);
  713.     break;
  714.     }
  715. }
  716.  
  717. static void show_bars()
  718. {
  719.     /* I really like this: "terrorbars" ;-) */
  720.     if (bar_size > 0.0)
  721.     fprintf(stderr, "\terrorbars are plotted with bars of size %f\n",
  722.         bar_size);
  723.     else
  724.     fputs("\terrors are plotted without bars\n", stderr);
  725. }
  726.  
  727. static void show_boxwidth()
  728. {
  729.     if (boxwidth < 0.0)
  730.     fputs("\tboxwidth is auto\n", stderr);
  731.     else
  732.     fprintf(stderr, "\tboxwidth is %g\n", boxwidth);
  733. }
  734. static void show_dgrid3d()
  735. {
  736.     if (dgrid3d)
  737.     fprintf(stderr, "\
  738. \tdata grid3d is enabled for mesh of size %dx%d, norm=%d\n",
  739.         dgrid3d_row_fineness,
  740.         dgrid3d_col_fineness,
  741.         dgrid3d_norm_value);
  742.     else
  743.     fputs("\tdata grid3d is disabled\n", stderr);
  744. }
  745.  
  746. static void show_range(axis, min, max, autosc, text)
  747. int axis;
  748. double min, max;
  749. TBOOLEAN autosc;
  750. char *text;
  751. {
  752.     /* this probably ought to just invoke save_range(stderr) from misc.c
  753.      * since I think it is identical
  754.      */
  755.  
  756.     if (datatype[axis] == TIME)
  757.     fprintf(stderr, "\tset %sdata time\n", text);
  758.     fprintf(stderr, "\tset %srange [", text);
  759.     if (autosc & 1) {
  760.     fputc('*', stderr);
  761.     } else {
  762.     SHOW_NUM_OR_TIME(min, axis);
  763.     }
  764.     fputs(" : ", stderr);
  765.     if (autosc & 2) {
  766.     fputc('*', stderr);
  767.     } else {
  768.     SHOW_NUM_OR_TIME(max, axis);
  769.     }
  770.     fprintf(stderr, "] %sreverse %swriteback",
  771.         (range_flags[axis] & RANGE_REVERSE) ? "" : "no",
  772.         (range_flags[axis] & RANGE_WRITEBACK) ? "" : "no");
  773.  
  774.     if (autosc) {
  775.     /* add current (hidden) range as comments */
  776.     fputs("  # (currently [", stderr);
  777.     if (autosc & 1) {
  778.         SHOW_NUM_OR_TIME(min, axis);
  779.     }
  780.     putc(':', stderr);
  781.     if (autosc & 2) {
  782.         SHOW_NUM_OR_TIME(max, axis);
  783.     }
  784.     fputs("] )\n", stderr);
  785.     } else {
  786.     putc('\n', stderr);
  787.     }
  788. }
  789.  
  790. static void show_zero()
  791. {
  792.     fprintf(stderr, "\tzero is %g\n", zero);
  793. }
  794.  
  795. static void show_offsets()
  796. {
  797.     fprintf(stderr, "\toffsets are %g, %g, %g, %g\n", loff, roff, toff, boff);
  798. }
  799.  
  800. static void show_border()
  801. {
  802.     fprintf(stderr, "\tborder is %sdrawn %d\n", draw_border ? "" : "not ",
  803.         draw_border);
  804.     /* HBB 980609: added facilities to specify border linestyle */
  805.     fprintf(stderr, "\tBorder drawn with linetype %d, linewidth %.3f\n",
  806.         border_lp.l_type + 1, border_lp.l_width);
  807. }
  808.  
  809. static void show_output()
  810. {
  811.     if (outstr)
  812.     fprintf(stderr, "\toutput is sent to '%s'\n", outstr);
  813.     else
  814.     fputs("\toutput is sent to STDOUT\n", stderr);
  815. }
  816.  
  817. static void show_samples()
  818. {
  819.     fprintf(stderr, "\tsampling rate is %d, %d\n", samples_1, samples_2);
  820. }
  821.  
  822. static void show_isosamples()
  823. {
  824.     fprintf(stderr, "\tiso sampling rate is %d, %d\n",
  825.         iso_samples_1, iso_samples_2);
  826. }
  827.  
  828. static void show_surface()
  829. {
  830.     fprintf(stderr, "\tsurface is %sdrawn\n", draw_surface ? "" : "not ");
  831. }
  832.  
  833. static void show_hidden3d()
  834. {
  835. #ifdef LITE
  836.     printf(" Hidden Line Removal Not Supported in LITE version\n");
  837. #else
  838.     fprintf(stderr, "\thidden surface is %s\n", hidden3d ? "removed" : "drawn");
  839.     show_hidden3doptions();
  840. #endif /* LITE */
  841. }
  842.  
  843. static void show_label_contours()
  844. {
  845.     if (label_contours)
  846.     fprintf(stderr, "\tcontour line types are varied & labeled with format '%s'\n", contour_format);
  847.     else
  848.     fputs("\tcontour line types are all the same\n", stderr);
  849. }
  850.  
  851. static void show_view()
  852. {
  853.     fprintf(stderr, "\tview is %g rot_x, %g rot_z, %g scale, %g scale_z\n",
  854.         surface_rot_x, surface_rot_z, surface_scale, surface_zscale);
  855. }
  856.  
  857. static void show_size()
  858. {
  859.     fprintf(stderr, "\tsize is scaled by %g,%g\n", xsize, ysize);
  860.     if (aspect_ratio > 0)
  861.     fprintf(stderr, "\tTry to set aspect ratio to %g:1.0\n", aspect_ratio);
  862.     else if (aspect_ratio == 0)
  863.     fputs("\tNo attempt to control aspect ratio\n", stderr);
  864.     else
  865.     fprintf(stderr, "\tTry to set LOCKED aspect ratio to %g:1.0\n",
  866.         -aspect_ratio);
  867. }
  868.  
  869. static void show_origin()
  870. {
  871.     fprintf(stderr, "\torigin is set to %g,%g\n", xoffset, yoffset);
  872. }
  873.  
  874. static void show_xyzlabel(name, label)
  875. char *name;
  876. label_struct *label;
  877. {
  878.     char str[MAX_LINE_LEN + 1];
  879.     fprintf(stderr, "\t%s is \"%s\", offset at %f, %f",
  880.       name, conv_text(str, label->text), label->xoffset, label->yoffset);
  881.     if (*label->font)
  882.     fprintf(stderr, ", using font \"%s\"", conv_text(str, label->font));
  883.     putc('\n', stderr);
  884. }
  885.  
  886. static void show_keytitle()
  887. {
  888.     char str[MAX_LINE_LEN+1];
  889.     fprintf(stderr, "\tkeytitle is \"%s\"\n",
  890.         conv_text(str, key_title));
  891. }
  892.  
  893. static void show_timefmt()
  894. {
  895.     char str[MAX_LINE_LEN+1];
  896.     fprintf(stderr, "\tread format for time is \"%s\"\n",
  897.         conv_text(str, timefmt));
  898. }
  899.  
  900. static void show_locale()
  901. {
  902.     fprintf(stderr, "\tlocale is \"%s\"\n", cur_locale);
  903. }
  904.  
  905. static void show_xzeroaxis()
  906. {
  907.     if (xzeroaxis.l_type > -3)
  908.     fprintf(stderr, "\txzeroaxis is drawn with linestyle %d, linewidth %.3f\n", xzeroaxis.l_type + 1, xzeroaxis.l_width);
  909.     else
  910.     fputs("\txzeroaxis is OFF\n", stderr);
  911.     if (x2zeroaxis.l_type > -3)
  912.     fprintf(stderr, "\tx2zeroaxis is drawn with linestyle %d, linewidth %.3f\n", x2zeroaxis.l_type + 1, x2zeroaxis.l_width);
  913.     else
  914.     fputs("\tx2zeroaxis is OFF\n", stderr);
  915. }
  916.  
  917. static void show_yzeroaxis()
  918. {
  919.     if (yzeroaxis.l_type > -3)
  920.     fprintf(stderr, "\tyzeroaxis is drawn with linestyle %d, linewidth %.3f\n", yzeroaxis.l_type + 1, yzeroaxis.l_width);
  921.     else
  922.     fputs("\tyzeroaxis is OFF\n", stderr);
  923.     if (y2zeroaxis.l_type > -3)
  924.     fprintf(stderr, "\ty2zeroaxis is drawn with linestyle %d, linewidth %.3f\n", y2zeroaxis.l_type + 1, y2zeroaxis.l_width);
  925.     else
  926.     fputs("\ty2zeroaxis is OFF\n", stderr);
  927. }
  928.  
  929. static void show_label(tag)
  930. int tag;            /* 0 means show all */
  931. {
  932.     struct text_label *this_label;
  933.     TBOOLEAN showed = FALSE;
  934.     char str[MAX_LINE_LEN + 1];
  935.  
  936.     for (this_label = first_label; this_label != NULL;
  937.      this_label = this_label->next) {
  938.     if (tag == 0 || tag == this_label->tag) {
  939.         showed = TRUE;
  940.         fprintf(stderr, "\tlabel %d \"%s\" at ",
  941.             this_label->tag, conv_text(str, this_label->text));
  942.         show_position(&this_label->place);
  943.         switch (this_label->pos) {
  944.         case LEFT:{
  945.             fputs(" left", stderr);
  946.             break;
  947.         }
  948.         case CENTRE:{
  949.             fputs(" centre", stderr);
  950.             break;
  951.         }
  952.         case RIGHT:{
  953.             fputs(" right", stderr);
  954.             break;
  955.         }
  956.         }
  957.         fprintf(stderr, " %s ", this_label->rotate ? "rotated (if possible)" : "not rotated");
  958.         if ((this_label->font)[0] != NUL)
  959.         fprintf(stderr, " font \"%s\"", this_label->font);
  960.         /* Entry font added by DJL */
  961.         fputc('\n', stderr);
  962.     }
  963.     }
  964.     if (tag > 0 && !showed)
  965.     int_error("label not found", c_token);
  966. }
  967.  
  968. static void show_arrow(tag)
  969. int tag;            /* 0 means show all */
  970. {
  971.     struct arrow_def *this_arrow;
  972.     TBOOLEAN showed = FALSE;
  973.  
  974.     for (this_arrow = first_arrow; this_arrow != NULL;
  975.      this_arrow = this_arrow->next) {
  976.     if (tag == 0 || tag == this_arrow->tag) {
  977.         showed = TRUE;
  978.         fprintf(stderr, "\tarrow %d, linetype %d, linewidth %.3f %s\n\t  from ",
  979.             this_arrow->tag,
  980.             this_arrow->lp_properties.l_type + 1,
  981.             this_arrow->lp_properties.l_width,
  982.             this_arrow->head ? "" : " (nohead)");
  983.         show_position(&this_arrow->start);
  984.         fputs(" to ", stderr);
  985.         show_position(&this_arrow->end);
  986.         putc('\n', stderr);
  987.     }
  988.     }
  989.     if (tag > 0 && !showed)
  990.     int_error("arrow not found", c_token);
  991. }
  992.  
  993. static void show_linestyle(tag)
  994. int tag;            /* 0 means show all */
  995. {
  996.     struct linestyle_def *this_linestyle;
  997.     TBOOLEAN showed = FALSE;
  998.  
  999.     for (this_linestyle = first_linestyle; this_linestyle != NULL;
  1000.      this_linestyle = this_linestyle->next) {
  1001.     if (tag == 0 || tag == this_linestyle->tag) {
  1002.         showed = TRUE;
  1003.         fprintf(stderr, "\tlinestyle %d, linetype %d, linewidth %.3f, pointtype %d, pointsize %.3f\n",
  1004.             this_linestyle->tag,
  1005.             this_linestyle->lp_properties.l_type + 1,
  1006.             this_linestyle->lp_properties.l_width,
  1007.             this_linestyle->lp_properties.p_type + 1,
  1008.             this_linestyle->lp_properties.p_size);
  1009.     }
  1010.     }
  1011.     if (tag > 0 && !showed)
  1012.     int_error("linestyle not found", c_token);
  1013. }
  1014.  
  1015. static void show_grid()
  1016. {
  1017.     if (!work_grid.l_type) {
  1018.     fputs("\tgrid is OFF\n", stderr);
  1019.     return;
  1020.     }
  1021.     fprintf(stderr, "\t%s grid drawn at%s%s%s%s%s%s%s%s%s%s tics\n",
  1022.         (polar_grid_angle != 0) ? "Polar" : "Rectangular",
  1023.         work_grid.l_type & GRID_X ? " x" : "",
  1024.         work_grid.l_type & GRID_Y ? " y" : "",
  1025.         work_grid.l_type & GRID_Z ? " z" : "",
  1026.         work_grid.l_type & GRID_X2 ? " x2" : "",
  1027.         work_grid.l_type & GRID_Y2 ? " y2" : "",
  1028.         work_grid.l_type & GRID_MX ? " mx" : "",
  1029.         work_grid.l_type & GRID_MY ? " my" : "",
  1030.         work_grid.l_type & GRID_MZ ? " mz" : "",
  1031.         work_grid.l_type & GRID_MX2 ? " mx2" : "",
  1032.         work_grid.l_type & GRID_MY2 ? " my2" : "");
  1033.  
  1034.     fprintf(stderr, "\tMajor grid drawn with linetype %d, linewidth %.3f\n",
  1035.         grid_lp.l_type + 1, grid_lp.l_width);
  1036.     fprintf(stderr, "\tMinor grid drawn with linetype %d, linewidth %.3f\n",
  1037.         mgrid_lp.l_type + 1, mgrid_lp.l_width);
  1038.  
  1039.     if (polar_grid_angle)
  1040.     fprintf(stderr, "\tGrid radii drawn every %f %s\n",
  1041.         polar_grid_angle / ang2rad,
  1042.         angles_format == ANGLES_DEGREES ? "degrees" : "radians");
  1043. }
  1044.  
  1045. static void show_mtics(minitic, minifreq, name)
  1046. int minitic;
  1047. double minifreq;
  1048. char *name;
  1049. {
  1050.     switch (minitic) {
  1051.     case MINI_OFF:
  1052.     fprintf(stderr, "\tminor %stics are off\n", name);
  1053.     break;
  1054.     case MINI_DEFAULT:
  1055.     fprintf(stderr, "\tminor %stics are computed automatically for log scales\n", name);
  1056.     break;
  1057.     case MINI_AUTO:
  1058.     fprintf(stderr, "\tminor %stics are computed automatically\n", name);
  1059.     break;
  1060.     case MINI_USER:
  1061.     fprintf(stderr, "\tminor %stics are drawn with %d subintervals between major xtic marks\n", name, (int) minifreq);
  1062.     break;
  1063.     default:
  1064.     int_error("Unknown minitic type in show_mtics()", NO_CARET);
  1065.     }
  1066. }
  1067.  
  1068. static void show_key()
  1069. {
  1070.     char str[80];
  1071.     *str = '\0';
  1072.     switch (key) {
  1073.     case -1:
  1074.     if (key_vpos == TUNDER) {
  1075.         strcpy(str, "below");
  1076.     } else if (key_vpos == TTOP) {
  1077.         strcpy(str, "top");
  1078.     } else {
  1079.         strcpy(str, "bottom");
  1080.     }
  1081.     if (key_hpos == TOUT) {
  1082.         strcpy(str, "outside (right)");
  1083.     } else if (key_hpos == TLEFT) {
  1084.         strcat(str, " left");
  1085.     } else {
  1086.         strcat(str, " right");
  1087.     }
  1088.     if (key_vpos != TUNDER && key_hpos != TOUT) {
  1089.         strcat(str, " corner");
  1090.     }
  1091.     fprintf(stderr, "\tkey is ON, position: %s\n", str);
  1092.     break;
  1093.     case 0:
  1094.     fputs("\tkey is OFF\n", stderr);
  1095.     break;
  1096.     case 1:
  1097.     fputs("\tkey is at ", stderr);
  1098.     show_position(&key_user_pos);
  1099.     putc('\n', stderr);
  1100.     break;
  1101.     }
  1102.     if (key) {
  1103.     fprintf(stderr, "\tkey is %s justified, %s reversed and ",
  1104.         key_just == JLEFT ? "left" : "right",
  1105.         key_reverse ? "" : "not");
  1106.     if (key_box.l_type >= -2)
  1107.         fprintf(stderr, "boxed\n\twith linetype %d, linewidth %.3f\n",
  1108.             key_box.l_type + 1, key_box.l_width);
  1109.     else
  1110.         fprintf(stderr, "not boxed\n\
  1111. \tsample length is %g characters\n\
  1112. \tvertical spacing is %g characters\n\
  1113. \twidth adjustment is %g characters\n\
  1114. \tkey title is \"%s\"\n",
  1115.     key_swidth,
  1116.     key_vert_factor,
  1117.     key_width_fix,
  1118.     key_title);
  1119.     }
  1120. }
  1121.  
  1122. static void show_parametric()
  1123. {
  1124.     fprintf(stderr, "\tparametric is %s\n", (parametric) ? "ON" : "OFF");
  1125. }
  1126.  
  1127. static void show_pointsize()
  1128. {
  1129.     fprintf(stderr, "\tpointsize is %g\n", pointsize);
  1130. }
  1131.  
  1132. static void show_encoding()
  1133. {
  1134.     fprintf(stderr, "\tencoding is %s\n", encoding_names[encodingb
  1135. gøgùgúgûgügþhXid show_polar()
  1136. {
  1137.     fprintf(stderr, "\tpolar is %s\n", (polar) ? "ON" : "OFF");
  1138. }
  1139.  
  1140. static void show_angles()
  1141. {
  1142.     fputs("\tAngles are in ", stderr);
  1143.     switch (angles_format) {
  1144.     case ANGLES_RADIANS:
  1145.     fputs("radians\n", stderr);
  1146.     break;
  1147.     case ANGLES_DEGREES:
  1148.     fputs("degrees\n", stderr);
  1149.     break;
  1150.     }
  1151. }
  1152.  
  1153.  
  1154. static void show_tics(showx, showy, showz, showx2, showy2)
  1155. TBOOLEAN showx, showy, showz, showx2, showy2;
  1156. {
  1157.     char str[MAX_LINE_LEN+1];
  1158.     fprintf(stderr, "\ttics are %s, \
  1159. \tticslevel is %g\n\
  1160. \tmajor ticscale is %g and minor ticscale is %g\n",
  1161.         (tic_in ? "IN" : "OUT"),
  1162.         ticslevel,
  1163.         ticscale, miniticscale);
  1164.  
  1165.     if (showx)
  1166.     show_ticdef(xtics, FIRST_X_AXIS, &xticdef, "x", rotate_xtics,
  1167.         conv_text(str, xformat));
  1168.     if (showx2)
  1169.     show_ticdef(x2tics, SECOND_X_AXIS, &x2ticdef, "x2", rotate_x2tics,
  1170.         conv_text(str, x2format));
  1171.     if (showy)
  1172.     show_ticdef(ytics, FIRST_Y_AXIS, &yticdef, "y", rotate_ytics,
  1173.         conv_text(str, yformat));
  1174.     if (showy2)
  1175.     show_ticdef(y2tics, SECOND_Y_AXIS, &y2ticdef, "y2", rotate_y2tics,
  1176.         conv_text(str, y2format));
  1177.     if (showz)
  1178.     show_ticdef(ztics, FIRST_Z_AXIS, &zticdef, "z", rotate_ztics,
  1179.         conv_text(str, zformat));
  1180.     screen_ok = FALSE;
  1181. }
  1182.  
  1183. /* called by show_tics */
  1184. static void show_ticdef(tics, axis, tdef, text, rotate_tics, ticfmt)
  1185. int tics;            /* xtics ytics or ztics */
  1186. int axis;
  1187. struct ticdef *tdef;        /* xticdef yticdef or zticdef */
  1188. char *text;            /* "x", ..., "x2", "y2" */
  1189. char *ticfmt;
  1190. int rotate_tics;
  1191. {
  1192.     register struct ticmark *t;
  1193.  
  1194.     fprintf(stderr, "\t%s-axis tics:\t", text);
  1195.     switch (tics & TICS_MASK) {
  1196.     case NO_TICS:
  1197.     fputs("OFF\n", stderr);
  1198.     return;
  1199.     case TICS_ON_AXIS:
  1200.     fputs("on axis", stderr);
  1201.         if (tics & TICS_MIRROR)
  1202.             fprintf(stderr, " and mirrored %s", (tic_in ? "OUT" : "IN"));
  1203.     break;
  1204.     case TICS_ON_BORDER:
  1205.     fputs("on border", stderr);
  1206.         if (tics & TICS_MIRROR)
  1207.             fputs(" and mirrored on opposite border", stderr);
  1208.     break;
  1209.     }
  1210.  
  1211.     fprintf(stderr,"\n\t  labels are format \"%s\"", ticfmt);
  1212.     if (rotate_tics)
  1213.     fputs(", rotated in 2D mode, terminal permitting.\n\t", stderr);
  1214.     else
  1215.     fputs(" and are not rotated\n\t", stderr);
  1216.  
  1217.     switch (tdef->type) {
  1218.     case TIC_COMPUTED:{
  1219.         fputs("  intervals computed automatically\n", stderr);
  1220.         break;
  1221.     }
  1222.     case TIC_MONTH:{
  1223.         fputs("  Months computed automatically\n", stderr);
  1224.         break;
  1225.     }
  1226.     case TIC_DAY:{
  1227.         fputs("  Days computed automatically\n", stderr);
  1228.         break;
  1229.     }
  1230.     case TIC_SERIES:{
  1231.         fputs("  series", stderr);
  1232.         if (tdef->def.series.start != -VERYLARGE) {
  1233.         fputs(" from ", stderr);
  1234.         SHOW_NUM_OR_TIME(tdef->def.series.start, axis);
  1235.         }
  1236.         fprintf(stderr, " by %g%s", tdef->def.series.incr, datatype[axis] == TIME ? " secs" : "");
  1237.         if (tdef->def.series.end != VERYLARGE) {
  1238.         fputs(" until ", stderr);
  1239.         SHOW_NUM_OR_TIME(tdef->def.series.end, axis);
  1240.         }
  1241.         putc('\n', stderr);
  1242.         break;
  1243.     }
  1244.     case TIC_USER:{
  1245. /* this appears to be unused? lh
  1246.         int time;
  1247.         time = (datatype[axis] == TIME);
  1248.  */
  1249.         fputs("  list (", stderr);
  1250.         for (t = tdef->def.user; t != NULL; t = t->next) {
  1251.         if (t->label) {
  1252.             char str[MAX_LINE_LEN+1];
  1253.             fprintf(stderr, "\"%s\" ", conv_text(str, t->label));
  1254.         }
  1255.         SHOW_NUM_OR_TIME(t->position, axis);
  1256.         if (t->next)
  1257.             fputs(", ", stderr);
  1258.         }
  1259.         fputs(")\n", stderr);
  1260.         break;
  1261.     }
  1262.     default:{
  1263.         int_error("unknown ticdef type in show_ticdef()", NO_CARET);
  1264.         /* NOTREACHED */
  1265.     }
  1266.     }
  1267. }
  1268.  
  1269.  
  1270. static void show_margin()
  1271. {
  1272.     if (lmargin >= 0)
  1273.     fprintf(stderr, "\tlmargin is set to %d\n", lmargin);
  1274.     else
  1275.     fputs("\tlmargin is computed automatically\n", stderr);
  1276.     if (bmargin >= 0)
  1277.     fprintf(stderr, "\tbmargin is set to %d\n", bmargin);
  1278.     else
  1279.     fputs("\tbmargin is computed automatically\n", stderr);
  1280.     if (rmargin >= 0)
  1281.     fprintf(stderr, "\trmargin is set to %d\n", rmargin);
  1282.     else
  1283.     fputs("\trmargin is computed automatically\n", stderr);
  1284.     if (tmargin >= 0)
  1285.     fprintf(stderr, "\ttmargin is set to %d\n", tmargin);
  1286.     else
  1287.     fputs("\ttmargin is computed automatically\n", stderr);
  1288. }
  1289.  
  1290. static void show_term()
  1291. {
  1292.     if (term)
  1293.     fprintf(stderr, "\tterminal type is %s %s\n",
  1294.         term->name, term_options);
  1295.     else
  1296.     fputs("\tterminal type is unknown\n", stderr);
  1297. }
  1298.  
  1299. static void show_plot()
  1300. {
  1301.     fprintf(stderr, "\tlast plot command was: %s\n", replot_line);
  1302. }
  1303.  
  1304. static void show_autoscale()
  1305. {
  1306.     fputs("\tautoscaling is ", stderr);
  1307.     if (parametric) {
  1308.     if (is_3d_plot) {
  1309.         fprintf(stderr, "\tt: %s%s%s, ",
  1310.             (autoscale_t) ? "ON" : "OFF",
  1311.             (autoscale_t == 1) ? " (min)" : "",
  1312.             (autoscale_t == 2) ? " (max)" : "");
  1313.     } else {
  1314.         fprintf(stderr, "\tu: %s%s%s, ",
  1315.             (autoscale_u) ? "ON" : "OFF",
  1316.             (autoscale_u == 1) ? " (min)" : "",
  1317.             (autoscale_u == 2) ? " (max)" : "");
  1318.         fprintf(stderr, "v: %s%s%s, ",
  1319.             (autoscale_v) ? "ON" : "OFF",
  1320.             (autoscale_v == 1) ? " (min)" : "",
  1321.             (autoscale_v == 2) ? " (max)" : "");
  1322.     }
  1323.     } else
  1324.     putc('\t', stderr);
  1325.  
  1326.     if (polar) {
  1327.     fprintf(stderr, "r: %s%s%s, ", (autoscale_r) ? "ON" : "OFF",
  1328.         (autoscale_r == 1) ? " (min)" : "",
  1329.         (autoscale_r == 2) ? " (max)" : "");
  1330.     }
  1331.     fprintf(stderr, "x: %s%s%s, ", (autoscale_x) ? "ON" : "OFF",
  1332.         (autoscale_x == 1) ? " (min)" : "",
  1333.         (autoscale_x == 2) ? " (max)" : "");
  1334.     fprintf(stderr, "y: %s%s%s, ", (autoscale_y) ? "ON" : "OFF",
  1335.         (autoscale_y == 1) ? " (min)" : "",
  1336.         (autoscale_y == 2) ? " (max)" : "");
  1337.     fprintf(stderr, "x2: %s%s%s, ", (autoscale_x2) ? "ON" : "OFF",
  1338.         (autoscale_x2 == 1) ? " (min)" : "",
  1339.         (autoscale_x2 == 2) ? " (max)" : "");
  1340.     fprintf(stderr, "y2: %s%s%s, ", (autoscale_y2) ? "ON" : "OFF",
  1341.         (autoscale_y2 == 1) ? " (min)" : "",
  1342.         (autoscale_y2 == 2) ? " (max)" : "");
  1343.     fprintf(stderr, "z: %s%s%s\n", (autoscale_z) ? "ON" : "OFF",
  1344.         (autoscale_z == 1) ? " (min)" : "",
  1345.         (autoscale_z == 2) ? " (max)" : "");
  1346. }
  1347.  
  1348. static void show_clip()
  1349. {
  1350.     fprintf(stderr, "\tpoint clip is %s\n", (clip_points) ? "ON" : "OFF");
  1351.  
  1352.     if (clip_lines1)
  1353.     fputs("\tdrawing and clipping lines between inrange and outrange points\n", stderr);
  1354.     else
  1355.     fputs("\tnot drawing lines between inrange and outrange points\n", stderr);
  1356.  
  1357.     if (clip_lines2)
  1358.     fputs("\tdrawing and clipping lines between two outrange points\n", stderr);
  1359.     else
  1360.     fputs("\tnot drawing lines between two outrange points\n", stderr);
  1361. }
  1362.  
  1363. static void show_mapping()
  1364. {
  1365.     fputs("\tmapping for 3-d data is ", stderr);
  1366.  
  1367.     switch (mapping3d) {
  1368.     case MAP3D_CARTESIAN:
  1369.     fputs("cartesian\n", stderr);
  1370.     break;
  1371.     case MAP3D_SPHERICAL:
  1372.     fputs("spherical\n", stderr);
  1373.     break;
  1374.     case MAP3D_CYLINDRICAL:
  1375.     fputs("cylindrical\n", stderr);
  1376.     break;
  1377.     }
  1378. }
  1379.  
  1380. static void show_contour()
  1381. {
  1382.     fprintf(stderr, "\tcontour for surfaces are %s",
  1383.         (draw_contour) ? "drawn" : "not drawn\n");
  1384.  
  1385.     if (draw_contour) {
  1386.     fprintf(stderr, " in %d levels on ", contour_levels);
  1387.     switch (draw_contour) {
  1388.     case CONTOUR_BASE:
  1389.         fputs("grid base\n", stderr);
  1390.         break;
  1391.     case CONTOUR_SRF:
  1392.         fputs("surface\n", stderr);
  1393.         break;
  1394.     case CONTOUR_BOTH:
  1395.         fputs("grid base and surface\n", stderr);
  1396.         break;
  1397.     }
  1398.     switch (contour_kind) {
  1399.     case CONTOUR_KIND_LINEAR:
  1400.         fputs("\t\tas linear segments\n", stderr);
  1401.         break;
  1402.     case CONTOUR_KIND_CUBIC_SPL:
  1403.         fprintf(stderr, "\t\tas cubic spline interpolation segments with %d pts\n", contour_pts);
  1404.         break;
  1405.     case CONTOUR_KIND_BSPLINE:
  1406.         fprintf(stderr, "\t\tas bspline approximation segments of order %d with %d pts\n", contour_order, contour_pts);
  1407.         break;
  1408.     }
  1409.     switch (levels_kind) {
  1410.     case LEVELS_AUTO:
  1411.         fprintf(stderr, "\t\tapprox. %d automatic levels\n", contour_levels);
  1412.         break;
  1413.     case LEVELS_DISCRETE:
  1414.         {
  1415.         int i;
  1416.         fprintf(stderr, "\t\t%d discrete levels at ", contour_levels);
  1417.         fprintf(stderr, "%g", levels_list[0]);
  1418.         for (i = 1; i < contour_levels; i++)
  1419.             fprintf(stderr, ",%g ", levels_list[i]);
  1420.         putc('\n', stderr);
  1421.         break;
  1422.         }
  1423.     case LEVELS_INCREMENTAL:
  1424.         fprintf(stderr, "\t\t%d incremental levels starting at %g, step %g, end %g\n", contour_levels, levels_list[0], levels_list[1],
  1425.          levels_list[0] + (contour_levels - 1) * levels_list[1]);
  1426.         /* contour-levels counts both ends */
  1427.         break;
  1428.     }
  1429.     /* fprintf(stderr,"\t\tcontour line types are %s\n", label_contours ? "varied" : "all the same"); */
  1430.     show_label_contours();
  1431.     }
  1432. }
  1433.  
  1434. static void show_format()
  1435. {
  1436.     char str[MAX_LINE_LEN+1];
  1437.  
  1438.     fprintf(stderr, "\ttic format is x-axis: \"%s\"", conv_text(str, xformat));
  1439.     fprintf(stderr, ", y-axis: \"%s\"", conv_text(str, yformat));
  1440.     fprintf(stderr, ", z-axis: \"%s\"", conv_text(str, zformat));
  1441.     fprintf(stderr, ", x2-axis: \"%s\"", conv_text(str, x2format));
  1442.     fprintf(stderr, ", y2-axis: \"%s\"\n", conv_text(str, y2format));
  1443. }
  1444.  
  1445. #define SHOW_LOG(FLAG, BASE, TEXT) \
  1446. if (FLAG) fprintf(stderr, "%s %s (base %g)", !count++ ? "\tlogscaling" : " and", TEXT,BASE)
  1447.  
  1448. static void show_logscale()
  1449. {
  1450.     int count = 0;
  1451.  
  1452.     SHOW_LOG(is_log_x, base_log_x, "x");
  1453.     SHOW_LOG(is_log_y, base_log_y, "y");
  1454.     SHOW_LOG(is_log_z, base_log_z, "z");
  1455.     SHOW_LOG(is_log_x2, base_log_x2, "x2");
  1456.     SHOW_LOG(is_log_y2, base_log_y2, "y2");
  1457.  
  1458.     if (count == 0)
  1459.     fputs("\tno logscaling\n", stderr);
  1460.     else if (count == 1)
  1461.     fputs(" only\n", stderr);
  1462.     else
  1463.     putc('\n', stderr);
  1464. }
  1465.  
  1466. static void show_variables()
  1467. {
  1468.     register struct udvt_entry *udv = first_udv;
  1469.     int len;
  1470.  
  1471.     fputs("\n\tVariables:\n", stderr);
  1472.     while (udv) {
  1473.     len = instring(udv->udv_name, ' ');
  1474.     fprintf(stderr, "\t%-*s ", len, udv->udv_name);
  1475.     if (udv->udv_undef)
  1476.         fputs("is undefined\n", stderr);
  1477.     else {
  1478.         fputs("= ", stderr);
  1479.         disp_value(stderr, &(udv->udv_value));
  1480.         (void) putc('\n', stderr);
  1481.     }
  1482.     udv = udv->next_udv;
  1483.     }
  1484. }
  1485.  
  1486. /*
  1487.  * Used in plot.c and misc.c
  1488.  * By adding FILE *fp, we can now use show_version()
  1489.  * to save version information to a file.
  1490.  */
  1491. void show_version(fp)
  1492. FILE *fp;
  1493. {
  1494.     /* If printed to a file, we prefix everything with
  1495.      * a hash mark to comment out the version information.
  1496.      */
  1497.     char prefix[6];        /* "#    " */
  1498.     char *p = prefix;
  1499.  
  1500.     prefix[0] = '#';
  1501.     prefix[1] = prefix[2] = prefix[3] = prefix[4] = ' ';
  1502.     prefix[5] = NUL;
  1503.  
  1504.     if (fp == stderr) {
  1505.     /* No hash mark - let p point to the trailing '\0' */
  1506.     p += sizeof(prefix) - 1;
  1507.     } else {
  1508. #ifdef GNUPLOT_BINDIR
  1509. # ifdef X11
  1510.     fprintf(fp, "#!%s/gnuplot -persist\n#\n", GNUPLOT_BINDIR);
  1511. #  else
  1512.     fprintf(fp, "#!%s/gnuplot\n#\n", GNUPLOT_BINDIR);
  1513. # endif                /* not X11 */
  1514. #endif /* GNUPLOT_BINDIR */
  1515.     }
  1516.     fprintf(fp, "%s\n\
  1517. %s\t%s\n\
  1518. %s\t%sversion %s\n\
  1519. %s\tpatchlevel %s\n\
  1520. %s\tlast modified %s\n\
  1521. %s\n\
  1522. %s\t%s\n\
  1523. %s\tThomas Williams, Colin Kelley and many others\n\
  1524. %s\n\
  1525. %s\tType `help` to access the on-line reference manual\n\
  1526. %s\tThe gnuplot FAQ is available from\n\
  1527. %s\t<%s>\n\
  1528. %s\n\
  1529. %s\tSend comments and requests for help to <%s>\n\
  1530. %s\tSend bugs, suggestions and mods to <%s>\n\
  1531. %s\n",
  1532.         p,            /* empty line */
  1533.         p, PROGRAM,
  1534.         p, OS, version,
  1535.         p, patchlevel,
  1536.         p, date,
  1537.         p,            /* empty line */
  1538.         p, gnuplot_copyright,
  1539.         p,            /* authors */
  1540.         p,            /* empty line */
  1541.         p,            /* Type help */
  1542.         p,            /* FAQ is at */
  1543.         p, faq_location,
  1544.         p,            /* empty line */
  1545.         p, help_email,
  1546.         p, bug_email,
  1547.         p);            /* empty line */
  1548. }
  1549.  
  1550. void show_version_long()
  1551. {
  1552.     char *helpfile = NULL;
  1553. #ifdef HAVE_SYS_UTSNAME_H
  1554.     struct utsname uts;
  1555.  
  1556.     /* something is fundamentally wrong if this fails ... */
  1557.     if (uname(&uts) > -1) {
  1558. # ifdef _AIX
  1559.     fprintf(stderr, "\nSystem: %s %s.%s", uts.sysname, uts.version, uts.release);
  1560. # elif defined (SCO)
  1561.     fprintf(stderr, "\nSystem: SCO %s", uts.release);
  1562. # else
  1563.     fprintf(stderr, "\nSystem: %s %s", uts.sysname, uts.release);
  1564. # endif
  1565.     } else {
  1566.     fprintf(stderr, "\n%s\n", OS);
  1567.     }
  1568.  
  1569. #else /* ! HAVE_SYS_UTSNAME_H */
  1570.  
  1571.     fprintf(stderr, "\n%s\n", OS);
  1572.  
  1573. #endif /* HAVE_SYS_UTSNAME_H */
  1574.  
  1575.     fputs("\nCompile options:\n", stderr);
  1576.  
  1577.     {
  1578.     /* The following code could be a lot simpler if
  1579.      * it wasn't for Borland's broken compiler ...
  1580.      */
  1581.     const char *rdline, *gnu_rdline, *libgd, *libpng, *linuxvga,
  1582.     *nocwdrc, *x11, *unixplot, *gnugraph;
  1583.  
  1584.     rdline =
  1585. #ifdef READLINE
  1586.         "+READLINE  "
  1587. #else
  1588.         "-READLINE  "
  1589. #endif
  1590.         ,gnu_rdline =
  1591. #ifdef HAVE_LIBREADLINE
  1592.         "+LIBREADLINE  "
  1593. #else
  1594.         "-LIBREADLINE  "
  1595. #endif
  1596.         ,libgd =
  1597. #ifdef HAVE_LIBGD
  1598.         "+LIBGD  "
  1599. #else
  1600.         "-LIBGD  "
  1601. #endif
  1602.         ,libpng =
  1603. #ifdef HAVE_LIBPNG
  1604.         "+LIBPNG  "
  1605. #else
  1606.         "-LIBPNG  "
  1607. #endif
  1608.         ,linuxvga =
  1609. #ifdef LINUXVGA
  1610.         "+LINUXVGA  "
  1611. #else
  1612.         ""
  1613. #endif
  1614.         ,nocwdrc =
  1615. #ifdef NOCWDRC
  1616.         "+NOCWDRC  "
  1617. #else
  1618.         "-NOCWDRC  "
  1619. #endif
  1620.         ,x11 =
  1621.  
  1622. #ifdef X11
  1623.         "+X11  "
  1624. #else
  1625.         ""
  1626. #endif
  1627.         ,unixplot =
  1628. #ifdef UNIXPLOT
  1629.         "+UNIXPLOT  "
  1630. #else
  1631.         ""
  1632. #endif
  1633.         ,gnugraph =
  1634. #ifdef GNUGRAPH
  1635.         "+GNUGRAPH  "
  1636. #else
  1637.         ""
  1638. #endif
  1639.         ;
  1640.     fprintf(stderr, "%s%s%s%s%s%s%s%s%s\n\n", rdline, gnu_rdline,
  1641.           libgd, libpng, linuxvga, nocwdrc, x11, unixplot, gnugraph);
  1642.     }
  1643.  
  1644.     if ((helpfile = getenv("GNUHELP")) == NULL) {
  1645. #if defined(ATARI) || defined(MTOS)
  1646.     if ((helpfile = getenv("GNUPLOTPATH")) == NULL) {
  1647.         helpfile = HELPFILE;
  1648.     }
  1649. #else
  1650.     helpfile = HELPFILE;
  1651. #endif
  1652.     }
  1653.     fprintf(stderr, "HELPFILE     = \"%s\"\n\
  1654. FAQ location = <%s>\n\
  1655. CONTACT      = <%s>\n\
  1656. HELPMAIL     = <%s>\n", helpfile, faq_location, bug_email, help_email);
  1657. }
  1658.  
  1659. static void show_datatype(name, axis)
  1660. char *name;
  1661. int axis;
  1662. {
  1663.     fprintf(stderr, "\t%s is set to %s\n", name,
  1664.         datatype[axis] == TIME ? "time" : "numerical");
  1665. }
  1666.  
  1667. char *
  1668.  conv_text(s, t)
  1669. char *s, *t;
  1670. {
  1671.     /* convert unprintable characters as \okt, tab as \t, newline \n .. */
  1672.     char *r;
  1673.     r = s;
  1674.     while (*t != '\0') {
  1675.     switch (*t) {
  1676.     case '\t':
  1677.         *s++ = '\\';
  1678.         *s++ = 't';
  1679.         break;
  1680.     case '\n':
  1681.         *s++ = '\\';
  1682.         *s++ = 'n';
  1683.         break;
  1684. #ifndef OSK
  1685.     case '\r':
  1686.         *s++ = '\\';
  1687.         *s++ = 'r';
  1688.         break;
  1689. #endif
  1690.     case '"':
  1691.     case '\\':
  1692.         *s++ = '\\';
  1693.         *s++ = *t;
  1694.         break;
  1695.  
  1696.     default:{
  1697.         if ((*t & 0177) > 31 && (*t & 0177) < 127)
  1698.             *s++ = *t;
  1699.         else {
  1700.             *s++ = '\\';
  1701.             sprintf(s, "%o", *t);
  1702.             while (*s != '\0')
  1703.             s++;
  1704.         }
  1705.         }
  1706.     }
  1707.     t++;
  1708.     }
  1709.     *s = '\0';
  1710.     return (r);
  1711. }
  1712.  
  1713.  
  1714. static void show_position(pos)
  1715. struct position *pos;
  1716. {
  1717.     static char *msg[] =
  1718.     {"(first axes) ", "(second axes) ", "(graph units) ", "(screen units) "};
  1719.  
  1720.     assert(first_axes == 0 && second_axes == 1 && graph == 2 && screen == 3);
  1721.  
  1722.     fprintf(stderr, "(%s%g, %s%g, %s%g)",
  1723.         pos->scalex == first_axes ? "" : msg[pos->scalex], pos->x,
  1724.         pos->scaley == pos->scalex ? "" : msg[pos->scaley], pos->y,
  1725.         pos->scalez == pos->scaley ? "" : msg[pos->scalez], pos->z);
  1726.  
  1727. }
  1728.  
  1729. static void show_missing()
  1730. {
  1731.     if (missing_val == NULL)
  1732.     fputs("\tNo string is interpreted as missing data\n", stderr);
  1733.     else
  1734.     fprintf(stderr, "\t\"%s\" is interpreted as missing value\n", missing_val);
  1735. }
  1736.